<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>akka.transactor.Coordinated</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../../lib/template.css" />
      <script type="text/javascript" src="../../lib/jquery.js"></script>
      <script type="text/javascript" src="../../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../../lib/template.js"></script>
      <script type="text/javascript" src="../../lib/tools.tooltip.js"></script>
    
        </head>
        <body class="type">
      <div id="definition">
        <a title="Go to companion" href="Coordinated$.html"><img src="../../lib/class_to_object_big.png" /></a>
        <p id="owner"><a name="akka" class="extype" href="../package.html">akka</a>.<a name="akka.transactor" class="extype" href="package.html">transactor</a></p>
        <h1><a title="Go to companion" href="Coordinated$.html">Coordinated</a></h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="kind">class</span>
      <span class="symbol">
        <span class="name">Coordinated</span>
        
        <span class="result"> extends AnyRef</span>
      </span>
      </h4>
      
          <div class="fullcommenttop" id="comment"><div class="comment cmt"><p><code>Coordinated</code> is a message wrapper that adds a <code>CommitBarrier</code> for explicitly
coordinating transactions across actors or threads.</p><p>Creating a <code>Coordinated</code> will create a commit barrier with initially one member.
For each member in the coordination set a transaction is expected to be created using
the coordinated atomic method, or the coordination cancelled using the cancel method.</p><p>The number of included members must match the number of transactions, otherwise a
successful transaction cannot be coordinated.
<br/><br/></p><p>To start a new coordinated transaction set that you will also participate in just create
a <code>Coordinated</code> object:</p><pre>
val coordinated = Coordinated()
</pre><p><br/></p><p>To start a coordinated transaction that you won't participate in yourself you can create a
<code>Coordinated</code> object with a message and send it directly to an actor. The recipient of the message
will be the first member of the coordination set:</p><pre>
actor ! Coordinated(Message)
</pre><p><br/></p><p>To receive a coordinated message in an actor simply match it in a case statement:</p><pre>
def receive = {
  case coordinated @ Coordinated(Message) =&gt; ...
}
</pre><p><br/></p><p>To include another actor in the same coordinated transaction set that you've created or
received, use the apply method on that object. This will increment the number of parties
involved by one and create a new <code>Coordinated</code> object to be sent.</p><pre>
actor ! coordinated(Message)
</pre><p><br/></p><p>To enter the coordinated transaction use the atomic method of the coordinated object:</p><pre>
coordinated.atomic { implicit txn =&gt;
  // do something in transaction ...
}
</pre><p>The coordinated transaction will wait for the other transactions before committing.
If any of the coordinated transactions fail then they all fail.
</p></div><dl class="attributes block"> <dt>See also</dt><dd><span class="cmt"><p>akka.actor.Transactor for an actor that implements coordinated transactions
</p></span></dd></dl><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent">AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
        

      <div id="template">

        <div id="mbrsel">
          <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
          <div id="order">
                <span class="filtertype">Ordering</span>
                <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
              </div>
          <div id="ancestors">
                <span class="filtertype">Inherited</span>
                <ol><li class="hideall out"><span>Hide All</span></li>
                <li class="showall in"><span>Show all</span></li></ol>
                <ol id="linearization"><li name="akka.transactor.Coordinated" class="in"><span>Coordinated</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
              </div>
          <div id="visbl">
              <span class="filtertype">Visibility</span>
              <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
            </div>
        </div>

        <div class="members" id="constructors">
              <h3>Instance Constructors</h3>
              <ol><li visbl="pub" name="akka.transactor.Coordinated#this" data-isabs="false">
      <a id="this:Coordinated"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol">
        <span class="name">Coordinated</span>
        
        <span class="params">(<span name="timeout">timeout: <a name="akka.util.Timeout" class="extype" href="../util/Timeout.html">Timeout</a></span>)</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="akka.transactor.Coordinated#this" data-isabs="false">
      <a id="this:Coordinated"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol">
        <span class="name">Coordinated</span>
        
        <span class="params">(<span name="message">message: <span name="scala.Any" class="extype">Any</span></span>, <span name="timeout">timeout: <a name="akka.util.Timeout" class="extype" href="../util/Timeout.html">Timeout</a></span>)</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="akka.transactor.Coordinated#this" data-isabs="false">
      <a id="this:Coordinated"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol">
        <span class="name">Coordinated</span>
        
        <span class="params">(<span name="message">message: <span name="scala.Any" class="extype">Any</span></span>, <span name="member">member: <span name="scala.concurrent.stm.CommitBarrier.Member" class="extype">Member</span></span>)</span>
      </span>
      </h4>
      
    </li></ol>
            </div>

        

        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">##</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#apply" data-isabs="false">
      <a id="apply(Any):Coordinated"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">apply</span>
        
        <span class="params">(<span name="msg">msg: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <a name="akka.transactor.Coordinated" class="extype" href="">Coordinated</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Create a new Coordinated object and increment the number of members by one.</p><div class="fullcomment"><div class="comment cmt"><p>Create a new Coordinated object and increment the number of members by one.
Use this method to <i>pass on</i> the coordination.
</p></div></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">asInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#atomic" data-isabs="false">
      <a id="atomic[A](Callable[A]):A"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">atomic</span>
        <span class="tparams">[<span name="A">A</span>]</span>
        <span class="params">(<span name="callable">callable: <span name="java.util.concurrent.Callable" class="extype">Callable</span>[A]</span>)</span><span class="result">: A</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Java API: coordinated atomic method that accepts a <code>java.util.concurrent.Callable</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Java API: coordinated atomic method that accepts a <code>java.util.concurrent.Callable</code>.
Delimits the coordinated transaction. The transaction will wait for all other transactions
in this coordination before committing. The timeout is specified when creating the Coordinated.
</p></div></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#atomic" data-isabs="false">
      <a id="atomic(Runnable):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">atomic</span>
        
        <span class="params">(<span name="runnable">runnable: <span name="java.lang.Runnable" class="extype">Runnable</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Java API: coordinated atomic method that accepts a <code>java.lang.Runnable</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Java API: coordinated atomic method that accepts a <code>java.lang.Runnable</code>.
Delimits the coordinated transaction. The transaction will wait for all other transactions
in this coordination before committing. The timeout is specified when creating the Coordinated.
</p></div></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#atomic" data-isabs="false">
      <a id="atomic[A]((InTxn) ⇒ A):A"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">atomic</span>
        <span class="tparams">[<span name="A">A</span>]</span>
        <span class="params">(<span name="body">body: (<span name="scala.concurrent.stm.InTxn" class="extype">InTxn</span>) ⇒ A</span>)</span><span class="result">: A</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Delimits the coordinated transaction.</p><div class="fullcomment"><div class="comment cmt"><p>Delimits the coordinated transaction. The transaction will wait for all other transactions
in this coordination before committing. The timeout is specified when creating the Coordinated.
</p></div></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#await" data-isabs="false">
      <a id="await():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">await</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">An empty coordinated atomic block.</p><div class="fullcomment"><div class="comment cmt"><p>An empty coordinated atomic block. Can be used to complete the number of members involved
and wait for all transactions to complete.
</p></div></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#cancel" data-isabs="false">
      <a id="cancel(Any):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">cancel</span>
        
        <span class="params">(<span name="info">info: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Cancel this Coordinated transaction.</p>
    </li><li visbl="prt" name="scala.AnyRef#clone" data-isabs="false">
      <a id="clone():AnyRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">clone</span>
        
        <span class="params">()</span><span class="result">: AnyRef</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#coordinate" data-isabs="false">
      <a id="coordinate(Any):Coordinated"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">coordinate</span>
        
        <span class="params">(<span name="msg">msg: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <a name="akka.transactor.Coordinated" class="extype" href="">Coordinated</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Java API: create a new Coordinated object and increment the number of members by one.</p><div class="fullcomment"><div class="comment cmt"><p>Java API: create a new Coordinated object and increment the number of members by one.
Use this method to <i>pass on</i> the coordination.
</p></div></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">eq</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">equals</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">finalize</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">getClass</span>
        
        <span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#getMessage" data-isabs="false">
      <a id="getMessage():Any"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">getMessage</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Any" class="extype">Any</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Java API: get the message for this Coordinated.</p>
    </li><li visbl="pub" name="scala.AnyRef#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">hashCode</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#message" data-isabs="false">
      <a id="message:Any"></a>
      <h4 class="signature">
      <span class="kind">val</span>
      <span class="symbol">
        <span class="name">message</span>
        
        <span class="result">: <span name="scala.Any" class="extype">Any</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ne</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="akka.transactor.Coordinated#noIncrement" data-isabs="false">
      <a id="noIncrement(Any):Coordinated"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">noIncrement</span>
        
        <span class="params">(<span name="msg">msg: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <a name="akka.transactor.Coordinated" class="extype" href="">Coordinated</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Create a new Coordinated object but *do not* increment the number of members by one.</p><div class="fullcomment"><div class="comment cmt"><p>Create a new Coordinated object but *do not* increment the number of members by one.
Only use this method if you know this is what you need.
</p></div></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notify</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notifyAll</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">synchronized</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toString</span>
        
        <span class="params">()</span><span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li></ol>
            </div>

        

        <div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>

      </div>

      <div id="tooltip"></div>

    </body>
      </html>